package com.lyd.generic.demo2;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author:lyd
 **/
public class GenericTest {
    public static void main(String[] args) {
        //定义一个泛型方法，交换两个元素的位置
//        Integer[] arr = {1, 2,6,8,10};
//        swapElement(arr,0,4);
//        System.out.println(Arrays.toString(arr));
//        System.out.println("------------------------------");
//        String[] str = {"aa", "bb", "cc", "dd"};
//        swapElement(str, 0, 3);
//        System.out.println(Arrays.toString(str));

        //定义一个泛型方法，用于查找数组中最大的值
//        Integer[] intArray = {12, 4, 56, 20, 95};
//        Integer maxElement = findMaxElement1(intArray);
//        System.out.println(maxElement);
//        System.out.println("-------------------------");
//        //自定义类实现比较
//        Person[] personArray={
//                new Person("张三",18),
//                new Person("李四",8),
//                new Person("王五",58),
//                new Person("王五",28)
//        };
//        Person person = findMaxElement1(personArray);
//        System.out.println(person);

        //使用Comparator比较器实现
//        Person[] personArray = {
//                new Person("张三", 18),
//                new Person("李四", 8),
//                new Person("王五", 58),
//                new Person("王五", 28)
//        };
//        Person maxElement2 = findMaxElement2(personArray, Comparator.comparing(Person::getAge));
//        System.out.println(maxElement2);
//        String[] words = {"apple", "banana", "cherry"};
//        System.out.println(findMaxElement2(words, String::compareTo));


        //定义一个泛型方法，用于打印数组中的所有元素
        Person[] personArray = {
                new Person("张三", 18),
                new Person("李四", 8),
                new Person("王五", 58),
                new Person("王五", 28)
        };
        printALl(personArray);
    }

    /**
     * 定义一个泛型方法，交换两个元素的位置
     *
     * @param arr
     * @param i
     * @param j
     * @param <T>
     */
    public static <T> void swapElement(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 定义一个泛型方法，用于查找数组中最大的值
     * 使用Comparable实现
     *
     * @param arr
     * @param <T> 返回值的类型
     *            <p>
     *            compareTo 的返回值：
     *            正数：当前对象 大于 被比较对象。
     *            零：当前对象 等于 被比较对象。
     *            负数：当前对象 小于 被比较对象。
     * @return
     */
    public static <T extends Comparable<T>> T findMaxElement1(T[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("数组不能为空或空数组");
        }
        T max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i].compareTo(max) > 0) {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 使用Comparator比较器实现
     *
     * @param array
     * @param comparator
     * @param <T>
     * @return
     */
    public static <T> T findMaxElement2(T[] array, Comparator<? super T> comparator) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("数组不能为空或空数组");
        }
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (comparator.compare(array[i], max) > 0) {
                max = array[i];
            }
        }
        return max;
    }

    /**
     * 定义一个泛型方法，用于打印数组中的所有元素
     * @param array
     * @param <T>
     */
    public static <T> void printALl(T[] array) {
        for (T t : array) {
            System.out.println(t);
        }
    }
}
